package logic

import (
	"context"
	"regexp"
	"strings"

	"mall/common/enumx"
	"mall/common/modelx"
	"mall/common/resultx"
	"mall/common/sqrlx"
	"mall/service/blog/model"
	"mall/service/blog/rpc/internal/svc"
	"mall/service/blog/rpc/types/blog"

	"github.com/zeromicro/go-zero/core/logx"
)

type PageListLogic struct {
	ctx    context.Context
	svcCtx *svc.ServiceContext
	logx.Logger
}

func NewPageListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PageListLogic {
	return &PageListLogic{
		ctx:    ctx,
		svcCtx: svcCtx,
		Logger: logx.WithContext(ctx),
	}
}

func (l *PageListLogic) PageList(in *blog.PageListRequest) (*blog.PageListResponse, error) {
	if in.Preload == "" && in.EagerLoad == "" {
		return nil, resultx.StatusError(resultx.REUQEST_PARAM_ERROR, "")
	}

	logx.Infof("PageListRequest: %+v ", in)
	// "{\"Preload\":\"blogPage:Slug\"}"

	preloadMap, eagerLoadMap := modelx.GetPreloadMap(in.Preload, in.EagerLoad)
	logx.Infof("preloadMap: %+v ", preloadMap)
	// preloadMap: map[blogPage:[Slug]]
	logx.Infof("eagerLoadMap: %+v ", eagerLoadMap)
	// eagerLoadMap:

	blogPageEntityName := model.RpcEntityNames.BlogPage
	_, hasEntitySettings := model.RpcEntityPreloadMap[blogPageEntityName] // BlogPage的关联字段
	if !hasEntitySettings {
		return &blog.PageListResponse{}, nil
	}

	blogPageRepositoryName := model.RepositoryNames.BlogPage
	columnMap, hasColumnMap := model.RepositoryPreloadMap[blogPageRepositoryName] // BlogPage的数据库字段
	if !hasColumnMap {
		return &blog.PageListResponse{}, nil
	}

	var selectCols []string
	if preloadFields, hasPreloadFields := preloadMap[blogPageEntityName]; hasPreloadFields {
		selectColMap := make(map[string]string)
		for _, field := range preloadFields {
			if _, exist := selectColMap[field]; !exist {
				if column, hasColumn := columnMap[field]; hasColumn {
					selectColMap[field] = column
				} else {
					selectColMap[field] = ""
				}
			}
		}
		for _, column := range selectColMap {
			if column != "" {
				selectCols = append(selectCols, column)
			}
		}
	}

	var filterMap map[string]map[string][]interface{}
	if in.Filter != "" {
		filterMap = modelx.GetFilterMap(in.Filter, columnMap)
		logx.Infof("filterMap: %+v ", filterMap)
		// filterMap: 
	}

	pageList, count, err := l.svcCtx.BlogPage.GetList(l.ctx, model.M{
		"offset": in.Offset,
		"limit":  in.Limit,
		"select": strings.Join(selectCols, ","),
	}, 2, filterMap)
	if err != nil {
		return nil, err
	}

	var pages []*blog.PageDetailResponse
	if len(pageList) > 0 {
		var pids []interface{} // []model.BlogPage.ID
		for _, page := range pageList {
			pids = append(pids, page.ID)
		}

		subRpcEntitySettingMap := make(map[string]map[string]*model.ColumnSetting)
		if eagerLoadRpcEntities, hasEagerLoadRpcEntities := eagerLoadMap[blogPageEntityName]; hasEagerLoadRpcEntities {
			for _, entity := range eagerLoadRpcEntities {
				if rpcEntitySettingMap, hasRpcEntitySettingMap := model.RpcEntityPreloadMap[entity]; hasRpcEntitySettingMap {
					subRpcEntitySettingMap[entity] = rpcEntitySettingMap
				}
			}
		}

		idMediaMap := make(map[uint64]*blog.BlogMedia) // Map: model.BlogPage.ID => *blog.BlogMedia
		blogMediaRpcEntityName := model.RpcEntityNames.BlogMedia
		blogMediaRepositoryName := model.RepositoryNames.BlogMedia
		if _, hasRpcEntitySettingMap := subRpcEntitySettingMap[blogMediaRpcEntityName]; hasRpcEntitySettingMap {
			preloadFields, hasPreloadFields := preloadMap[blogMediaRpcEntityName]
			subColumnMap, hasSubColumnMap := model.RepositoryPreloadMap[blogMediaRepositoryName]
			if hasPreloadFields && hasSubColumnMap {
				selectColMap := make(map[string]string)
				for _, field := range preloadFields {
					if _, exist := selectColMap[field]; !exist {
						if column, hasColumn := subColumnMap[field]; hasColumn {
							selectColMap[field] = column
						} else {
							selectColMap[field] = ""
						}
					}
				}
				var subSelectCols []string
				for _, column := range selectColMap {
					if column != "" {
						subSelectCols = append(subSelectCols, column)
					}
				}
				mediaFilterMap := make(map[string]map[string][]interface{})
				mediaFilterMap[model.BlogAttachmentRelationshipColumns.ObjectID] = map[string][]interface{}{
					"in": pids,
				}
				mediaFilterMap[model.BlogAttachmentRelationshipColumns.ObjectType] = map[string][]interface{}{
					"equalTo": []interface{}{enumx.PostTypePage},
				}
				mediaFilterMap[model.BlogAttachmentRelationshipColumns.AttachmentThumbnail] = map[string][]interface{}{
					"equalTo": []interface{}{1},
				}
				mediaList, _, err := l.svcCtx.BlogPage.GetMedia(l.ctx, model.M{
					"orderBy": model.BlogAttachmentRelationshipColumns.AttachmentOrder,
					"select": strings.Join(subSelectCols, ","),
				}, -1, mediaFilterMap)
				if err != nil {
					return nil, err
				}
				if len(mediaList) > 0 {
					for _, media := range mediaList {
						if _, exist := idMediaMap[media.ObjectID]; !exist {
							idMediaMap[media.ObjectID] = &blog.BlogMedia{
								Uid:       int64(media.AttachmentRelationshipID),
								Id:        int64(media.AttachmentID),
								Uri:       media.AttachmentSource,
								Thumbnail: int32(media.AttachmentThumbnail),
								Order:     int32(media.AttachmentOrder),
								Url:       media.AttachmentImageURL,
								AltText:   media.AttachmentImageAlt,
								Meta:      media.AttachmentImageMeta,
							}
						}
					}
				}
			}
		}

		idMetaMap := make(map[uint64]*blog.BlogMeta) // Map: model.BlogPage.ID => *blog.BlogMeta
		blogPageMetaRpcEntityName := model.RpcEntityNames.BlogPageMeta
		if rpcEntitySettingMap, hasRpcEntitySettingMap := subRpcEntitySettingMap[blogPageMetaRpcEntityName]; hasRpcEntitySettingMap {
			if preloadFields, hasPreloadFields := preloadMap[blogPageMetaRpcEntityName]; hasPreloadFields {
				var metaKeys []interface{}
				for _, field := range preloadFields {
					fieldSetting, hasFieldSetting := rpcEntitySettingMap[field]
					if hasFieldSetting && fieldSetting.Name != "" {
						metaKeys = append(metaKeys, fieldSetting.Name)
					}
				}
				if len(metaKeys) > 0 {
					metaFilterMap := make(map[string]map[string][]interface{})
					metaFilterMap[model.BlogPageMetumColumns.PageID] = map[string][]interface{}{
						"in": pids,
					}
					metaFilterMap[model.BlogPageMetumColumns.MetaKey] = map[string][]interface{}{
						"in": metaKeys,
					}
					metaList, _, err := l.svcCtx.BlogPage.GetMeta(l.ctx, model.M{}, -1, metaFilterMap)
					if err != nil {
						return nil, err
					}
					if len(metaList) > 0 {
						for _, metum := range metaList {
							if _, exist := idMetaMap[metum.PageID]; !exist {
								idMetaMap[metum.PageID] = &blog.BlogMeta{
									Id: int64(metum.MetaID),
									Key: metum.MetaKey,
									Value: metum.MetaValue.String,
								}
							}
						}
					}
				}
			}
		}

		for _, page := range pageList {
			var media []*blog.BlogMedia
			if m, exist := idMediaMap[page.ID]; exist {
				media = append(media, m)
			}
			var meta []*blog.BlogMeta
			if m, exist := idMetaMap[page.ID]; exist {
				meta = append(meta, m)
			}
			pages = append(pages, &blog.PageDetailResponse{
				Id:            int64(page.ID),
				AuthorId:      int64(page.PostAuthorID),
				ParentId:      int64(page.PostParentID),
				Title:         page.PostTitle,
				Excerpt:       page.PostExcerpt,
				Status:        int32(page.PostStatus),
				CommentStatus: int32(page.CommentStatus),
				Slug:          page.PostName,
				Uri:           page.GUID,
				Date:          modelx.FormatTime(page.PostDate, ""),
				DateGmt:       modelx.FormatTime(page.PostDateGMT, ""),
				Modified:      modelx.FormatTime(page.PostModifiedDate, ""),
				ModifiedGmt:   modelx.FormatTime(page.PostModifiedGMT, ""),
				CommentCount:  int32(page.CommentCount),
				SortOrder:     int64(page.MenuOrder),
				Media:         media,
				Meta:          meta,
			})
		}
	}

	var hasNextPage int32
	var hasPreviousPage int32
	if count > 1 {
		hasNextPage = 1
		count = count - 2
	}
	if count > 0 {
		hasPreviousPage = 1
	}
	return &blog.PageListResponse{
		Data: pages,
		HasNextPage: hasNextPage,
		HasPreviousPage: hasPreviousPage,
	}, nil
}

func (l *PageListLogic) GetTermIds(in *blog.TermListRequest) ([]int64, error) { /////
	// q := l.svcCtx.BlogTermModel.RowBuilder("t.`term_id`", "t")
	// q = q.OrderBy("t.`term_id` ASC")

	// var (
	// 	requireTaxonomy      bool
	// 	requireRelationships bool
	// )

	// if in.Name != "" {
	// 	q = q.Where(sq.Eq{"t.`name`": in.Name})
	// } else if in.NameIn != nil && len(in.NameIn) > 0 {
	// 	q = q.Where(sq.Eq{"t.`name`": in.NameIn})
	// } else if in.NameNotIn != nil && len(in.NameNotIn) > 0 {
	// 	q = q.Where(sq.NotEq{"t.`name`": in.NameNotIn})
	// }

	// if in.ObjectId > 0 {
	// 	requireRelationships = true
	// 	q = q.Where(sq.Eq{"tr.`object_id`": in.ObjectId})
	// } else if in.ObjectIdIn != nil && len(in.ObjectIdIn) > 0 {
	// 	requireRelationships = true
	// 	q = q.Where(sq.Eq{"tr.`object_id`": in.ObjectIdIn})
	// } else if in.ObjectIdNotIn != nil && len(in.ObjectIdNotIn) > 0 {
	// 	requireRelationships = true
	// 	q = q.Where(sq.NotEq{"tr.`object_id`": in.ObjectIdNotIn})
	// }

	// if in.ObjectType > 0 {
	// 	requireRelationships = true
	// 	q = q.Where(sq.NotEq{"tr.`object_type`": in.ObjectType})
	// }

	// if in.ParentId > 0 {
	// 	requireTaxonomy = true
	// 	q = q.Where(sq.Eq{"tt.`parent_id`": in.ParentId})
	// } else if in.ParentIdIn != nil && len(in.ParentIdIn) > 0 {
	// 	requireTaxonomy = true
	// 	q = q.Where(sq.Eq{"tt.`parent_id`": in.ParentIdIn})
	// } else if in.ParentIdNotIn != nil && len(in.ParentIdNotIn) > 0 {
	// 	requireTaxonomy = true
	// 	q = q.Where(sq.NotEq{"tt.`parent_id`": in.ParentIdNotIn})
	// }

	// if in.Slug != "" {
	// 	q = q.Where(sq.Eq{"t.`slug`": in.Slug})
	// } else if in.SlugIn != nil && len(in.SlugIn) > 0 {
	// 	q = q.Where(sq.Eq{"t.`slug`": in.SlugIn})
	// } else if in.SlugNotIn != nil && len(in.SlugNotIn) > 0 {
	// 	q = q.Where(sq.NotEq{"t.`slug`": in.SlugNotIn})
	// }

	// if in.Taxonomy != "" {
	// 	requireTaxonomy = true
	// 	q = q.Where(sq.Eq{"tt.`taxonomy`": in.Taxonomy})
	// } else if in.TaxonomyIn != nil && len(in.TaxonomyIn) > 0 {
	// 	requireTaxonomy = true
	// 	q = q.Where(sq.Eq{"tt.`taxonomy`": in.TaxonomyIn})
	// } else if in.TaxonomyNotIn != nil && len(in.TaxonomyNotIn) > 0 {
	// 	requireTaxonomy = true
	// 	q = q.Where(sq.NotEq{"tt.`taxonomy`": in.TaxonomyNotIn})
	// }

	// if in.Id > 0 {
	// 	q = q.Where(sq.Eq{"t.`term_id`": in.Id})
	// } else if in.IdIn != nil && len(in.IdIn) > 0 {
	// 	q = q.Where(sq.Eq{"t.`term_id`": in.IdIn})
	// } else if in.IdNotIn != nil && len(in.IdNotIn) > 0 {
	// 	q = q.Where(sq.NotEq{"t.`term_id`": in.IdNotIn})
	// }

	// if in.Offset > 0 {
	// 	q = q.Where("t.`term_id` > ?", in.Offset)
	// }

	// if in.Limit == 0 {
	// 	in.Limit = l.svcCtx.Config.Query.DefaultAmount
	// }

	// if in.Limit >= 0 {
	// 	q = q.Limit(uint64(in.Limit))
	// }

	// return l.svcCtx.BlogTermModel.QueryIds(l.ctx, q, requireTaxonomy, requireRelationships)
	return nil, nil
}

// getCategoryIdBySlug returns the id of the category that matches the given slug
func (l *PageListLogic) getCategoryIdBySlug(slug string, objectType int64) (int64, error) { /////
	slug = strings.TrimSpace(slug)
	if len(slug) == 0 {
		return 0, nil
	}

	parts := strings.Split(slug, "/") // 有 “/”，会先切割然后逐级核对，取最后一级分类的ID

	var categoryId int64
	for _, part := range parts {
		termIds, err := l.GetTermIds(&blog.TermListRequest{
			ObjectType: objectType,
			ParentId:   categoryId,
			Slug:       part,
			Taxonomy:   string(enumx.TaxonomyCategory),
		})

		if err != nil {
			return 0, err
		}

		if len(termIds) > 0 {
			categoryId = termIds[0]
		} else {
			return 0, nil
		}
	}

	return categoryId, nil
}

func (l *PageListLogic) GetChildrenIdsById(termId int64) ([]int64, error) { /////
	resp := []int64{termId}

	// ids := resp[:]
	// for len(ids) > 0 {
	// 	ids, err := l.svcCtx.BlogTermTaxonomyModel.GetChildrenIds(l.ctx, ids)
	// 	if err != nil {
	// 		break
	// 	}

	// 	resp = append(resp, ids...)
	// }

	return resp, nil
}

func (l *PageListLogic) parseCategoryFilter(in *blog.TermListRequest) { /////
	if in.Name != "" {
		var regexpCategoryNameSeparators = regexp.MustCompile("[,+~]")

		parseCategoryName := func(name string) {
			if name != "" {
				switch name[:1] {
				case "+":
					in.NameAnd = append(in.NameAnd, name[1:])
				case "~":
					in.NameNotIn = append(in.NameNotIn, name[1:])
				default:
					if name[:1] == "," {
						name = name[1:]
					}

					in.NameIn = append(in.NameIn, name)
				}
			}
		}

		prevIndex := 0
		for _, indices := range regexpCategoryNameSeparators.FindAllStringIndex(in.Name, -1) {
			parseCategoryName(in.Name[prevIndex:indices[0]])
			prevIndex = indices[0] // indices 包含start和length
		}
		parseCategoryName(in.Name[prevIndex:])

		in.Name = ""
	}

	if in.NameAnd != nil && len(in.NameAnd) > 0 {
		for _, name := range sqrlx.UniqueString(in.NameAnd) {
			catId, _ := l.getCategoryIdBySlug(name, in.ObjectType)
			if catId == 0 {
				continue
			}

			in.IdAnd = append(in.IdAnd, catId)
		}
	} else if in.NameIn != nil && len(in.NameIn) > 0 {
		for _, name := range sqrlx.UniqueString(in.NameIn) {
			catId, _ := l.getCategoryIdBySlug(name, in.ObjectType)
			if catId == 0 {
				continue
			}

			in.IdIn = append(in.IdIn, catId)
		}
	} else if in.NameNotIn != nil && len(in.NameNotIn) > 0 {
		for _, name := range sqrlx.UniqueString(in.NameNotIn) {
			catId, _ := l.getCategoryIdBySlug(name, in.ObjectType)
			if catId == 0 {
				continue
			}

			in.IdNotIn = append(in.IdNotIn, catId)
		}
	}
}

// func (l *PageListLogic) FilterList(in *blog.ObjectListRequest) ([]int64, error) {
// 	if in.AuthorName != "" {
// 		q = q.Where(sqrlx.InSubquery{
// 			Column: "post_author_id",
// 			Query:  userSubQuery.Where(sq.Eq{"user_nicename": in.AuthorName}),
// 		})
// 	} else if in.AuthorNameIn != nil && len(in.AuthorNameIn) > 0 {
// 		q = q.Where(sqrlx.InSubquery{
// 			Column: "post_author_id",
// 			Query:  userSubQuery.Where(sq.Eq{"user_nicename": in.AuthorNameIn}),
// 		})
// 	} else if in.AuthorNameNotIn != nil && len(in.AuthorNameNotIn) > 0 {
// 		q = q.Where(sqrlx.InSubquery{
// 			Column: "post_author_id",
// 			Query:  userSubQuery.Where(sq.Eq{"user_nicename": in.AuthorNameNotIn}),
// 			Neg:    true,
// 		})
// 	}

// 	if in.CategoryFilter != nil {
// 		l.parseCategoryFilter(in.CategoryFilter)

// 		if in.CategoryFilter.Id > 0 {
// 			ids, err := l.GetChildrenIdsById(in.CategoryFilter.Id)
// 			if err != nil {
// 				return nil, err
// 			}

// 			q = q.Where(sqrlx.InSubquery{
// 				Column: "ID",
// 				Query: termsSubQuery.Where(sq.Eq{
// 					"tt.`taxonomy`": string(enumx.TaxonomyCategory),
// 					"t.`term_id`":   ids,
// 				}),
// 			})
// 		} else if in.CategoryFilter.IdAnd != nil && len(in.CategoryFilter.IdAnd) > 0 {
// 			for _, categoryId := range sqrlx.UniqueInt64(in.CategoryFilter.IdAnd) {
// 				ids, err := l.GetChildrenIdsById(categoryId)
// 				if err != nil {
// 					return nil, err
// 				}

// 				q = q.Where(sqrlx.InSubquery{
// 					Column: "ID",
// 					Query: termsSubQuery.Where(sq.Eq{
// 						"tt.`taxonomy`": string(enumx.TaxonomyCategory),
// 						"t.`term_id`":   ids,
// 					}),
// 				})
// 			}
// 		} else if in.CategoryFilter.IdIn != nil && len(in.CategoryFilter.IdIn) > 0 {
// 			var catIds []int64
// 			for _, categoryId := range sqrlx.UniqueInt64(in.CategoryFilter.IdIn) {
// 				ids, err := l.GetChildrenIdsById(categoryId)
// 				if err != nil {
// 					return nil, err
// 				}

// 				catIds = append(catIds, ids...)
// 			}

// 			q = q.Where(sqrlx.InSubquery{
// 				Column: "ID",
// 				Query: termsSubQuery.Where(sq.Eq{
// 					"tt.`taxonomy`": string(enumx.TaxonomyCategory),
// 					"t.`term_id`":   sqrlx.UniqueInt64(catIds),
// 				}),
// 			})
// 		} else if in.CategoryFilter.IdNotIn != nil && len(in.CategoryFilter.IdNotIn) > 0 {
// 			var catIds []int64
// 			for _, categoryId := range sqrlx.UniqueInt64(in.CategoryFilter.IdNotIn) {
// 				ids, err := l.GetChildrenIdsById(categoryId)
// 				if err != nil {
// 					return nil, err
// 				}

// 				catIds = append(catIds, ids...)
// 			}

// 			q = q.Where(sqrlx.InSubquery{
// 				Column: "ID",
// 				Query: termsSubQuery.Where(sq.Eq{
// 					"tt.`taxonomy`": string(enumx.TaxonomyCategory),
// 					"t.`term_id`":   sqrlx.UniqueInt64(catIds),
// 				}),
// 				Neg: true,
// 			})
// 		}
// 	}

// 	var searchMeta = func(metas ...string) { // 按照meta_key（有'='，同时按照meta_value）查询
// 		neg := false
// 		if metas[0] == "is not in" {
// 			neg = true
// 			metas = metas[1:]
// 		}

// 		if len(metas) == 0 {
// 			return
// 		}

// 		var subQuery sq.SelectBuilder
// 		subQuery = l.svcCtx.BlogPageMetaModel.RowBuilder("", "")
// 		subQuery = subQuery.Distinct()

// 		var metaConds sq.Or
// 		for _, meta := range metas {
// 			metaCond := make(sq.Eq)
// 			if equal := strings.IndexRune(meta, '='); equal != -1 {
// 				metaCond["meta_value"] = meta[equal+1:]
// 				meta = meta[:equal]
// 			}
// 			metaCond["meta_key"] = meta
// 			metaConds = append(metaConds, metaCond)
// 		}

// 		q = q.Where(sqrlx.InSubquery{
// 			Column: "ID",
// 			Query:  subQuery.Where(metaConds),
// 			Neg:    neg,
// 		})
// 	}

// 	if in.Meta != "" { // 格式： "meta_key=meta_value"
// 		searchMeta(in.Meta)
// 	} else if in.MetaAnd != nil && len(in.MetaAnd) > 0 {
// 		for _, meta := range sqrlx.UniqueString(in.MetaAnd) {
// 			searchMeta(meta)
// 		}
// 	} else if in.MetaIn != nil && len(in.MetaIn) > 0 {
// 		searchMeta(sqrlx.UniqueString(in.MetaIn)...)
// 	} else if in.MetaNotIn != nil && len(in.MetaNotIn) > 0 {
// 		searchMeta(append([]string{"is not in"}, sqrlx.UniqueString(in.MetaNotIn)...)...)
// 	}

// 	if in.Name != "" {
// 		q = q.Where(sq.Eq{"post_name": in.Name})
// 	} else if in.NameIn != nil && len(in.NameIn) > 0 {
// 		q = q.Where(sq.Eq{"post_name": sqrlx.UniqueString(in.NameIn)})
// 	} else if in.NameNotIn != nil && len(in.NameNotIn) > 0 {
// 		q = q.Where(sq.NotEq{"post_name": sqrlx.UniqueString(in.NameNotIn)})
// 	}

// 	if in.Parent > 0 {
// 		q = q.Where(sq.Eq{"post_parent_id": in.Parent})
// 	} else if in.ParentIn != nil && len(in.ParentIn) > 0 {
// 		q = q.Where(sq.Eq{"post_parent_id": sqrlx.UniqueInt64(in.ParentIn)})
// 	} else if in.ParentNotIn != nil && len(in.ParentNotIn) > 0 {
// 		q = q.Where(sq.NotEq{"post_parent_id": sqrlx.UniqueInt64(in.ParentNotIn)})
// 	}

// 	if in.Post > 0 {
// 		q = q.Where(sq.Eq{"ID": in.Post})
// 	} else if in.PostIn != nil && len(in.PostIn) > 0 {
// 		q = q.Where(sq.Eq{"ID": sqrlx.UniqueInt64(in.PostIn)})
// 	} else if in.PostNotIn != nil && len(in.PostNotIn) > 0 {
// 		q = q.Where(sq.NotEq{"ID": sqrlx.UniqueInt64(in.PostNotIn)})
// 	}

// 	if in.TagId > 0 {
// 		q = q.Where(sqrlx.InSubquery{
// 			Column: "ID",
// 			Query: termsSubQuery.Where(sq.Eq{
// 				"tt.taxonomy": string(enumx.TaxonomyPostTag),
// 				"t.term_id":   in.TagId,
// 			}),
// 		})
// 	} else if in.TagIdAnd != nil && len(in.TagIdAnd) > 0 {
// 		for _, tagId := range sqrlx.UniqueInt64(in.TagIdAnd) {
// 			q = q.Where(sqrlx.InSubquery{
// 				Column: "ID",
// 				Query: termsSubQuery.Where(sq.Eq{
// 					"tt.taxonomy": string(enumx.TaxonomyPostTag),
// 					"t.term_id":   tagId,
// 				}),
// 			})
// 		}
// 	} else if in.TagIdIn != nil && len(in.TagIdIn) > 0 {
// 		q = q.Where(sqrlx.InSubquery{
// 			Column: "ID",
// 			Query: termsSubQuery.Where(sq.Eq{
// 				"tt.taxonomy": string(enumx.TaxonomyPostTag),
// 				"t.term_id":   sqrlx.UniqueInt64(in.TagIdIn),
// 			}),
// 		})
// 	} else if in.TagIdNotIn != nil && len(in.TagIdNotIn) > 0 {
// 		q = q.Where(sqrlx.InSubquery{
// 			Column: "ID",
// 			Query: termsSubQuery.Where(sq.Eq{
// 				"tt.taxonomy": string(enumx.TaxonomyPostTag),
// 				"t.term_id":   sqrlx.UniqueInt64(in.TagIdNotIn),
// 			}),
// 			Neg: true,
// 		})
// 	}

// 	if in.TagName != "" {
// 		q = q.Where(sqrlx.InSubquery{
// 			Column: "ID",
// 			Query: termsSubQuery.Where(sq.Eq{
// 				"tt.`taxonomy`": string(enumx.TaxonomyPostTag),
// 				"t.`slug`":      in.TagName,
// 			}),
// 		})
// 	} else if in.TagNameAnd != nil && len(in.TagNameAnd) > 0 {
// 		for _, tagName := range sqrlx.UniqueString(in.TagNameAnd) {
// 			q = q.Where(sqrlx.InSubquery{
// 				Column: "ID",
// 				Query: termsSubQuery.Where(sq.Eq{
// 					"tt.`taxonomy`": string(enumx.TaxonomyPostTag),
// 					"t.`slug`":      tagName,
// 				}),
// 			})
// 		}
// 	} else if in.TagNameIn != nil && len(in.TagNameIn) > 0 {
// 		q = q.Where(sqrlx.InSubquery{
// 			Column: "ID",
// 			Query: termsSubQuery.Where(sq.Eq{
// 				"tt.`taxonomy`": string(enumx.TaxonomyPostTag),
// 				"t.`slug`":      sqrlx.UniqueString(in.TagNameIn),
// 			}),
// 		})
// 	} else if in.TagNameNotIn != nil && len(in.TagNameNotIn) > 0 {
// 		q = q.Where(sqrlx.InSubquery{
// 			Column: "ID",
// 			Query: termsSubQuery.Where(sq.Eq{
// 				"tt.`taxonomy`": string(enumx.TaxonomyPostTag),
// 				"t.`slug`":      sqrlx.UniqueString(in.TagNameNotIn),
// 			}),
// 			Neg: true,
// 		})
// 	}

// 	if in.Query != "" { // 格式： 2个字符以上，','切分多个
// 		var pred string
// 		var args []interface{}
// 		for _, word := range regexpQueryDelimiter.Split(in.Query, -1) {
// 			if len(word) > 2 {
// 				pred += "post_name LIKE ? OR post_title LIKE ? OR "

// 				word = "%" + word + "%"
// 				args = append(args, word, word)
// 			}
// 		}

// 		if pred != "" {
// 			q = q.Where("("+pred[:len(pred)-4]+")", args...)
// 		}
// 	}

// 	if in.Day > 0 {
// 		q = q.Where(sq.Eq{"DAYOFMONTH(post_date)": in.Day}) // 返回日期在本月的第几天，范围为1到31
// 	}

// 	if in.Month > 0 {
// 		q = q.Where(sq.Eq{"MONTH(post_date)": in.Month}) // 返回指定日期的月份，1月至12月的范围为1到12
// 	}

// 	if in.Year > 0 {
// 		q = q.Where(sq.Eq{"YEAR(post_date)": in.Year}) // 返回指定日期的年份，在1000到9999之间
// 	}

// 	if in.AfterDate != "" {
// 		q = q.Where("post_date > ?", in.AfterDate)
// 	}

// 	if in.After > 0 {
// 		pred := "`ID`"
// 		if in.DefaultOrderAscending {
// 			pred += " > "
// 			q = q.OrderBy("`ID` ASC")
// 		} else {
// 			pred += " < "
// 			q = q.OrderBy("`ID` DESC")
// 		}
// 		pred += "?"

// 		q = q.Where(pred, in.After)
// 	}

// 	if in.OrderBy != nil && len(in.OrderBy) > 0 {
// 		for _, orderBy := range sqrlx.UniqueString(in.OrderBy) {
// 			q = q.OrderBy(orderBy)
// 		}
// 	}

// 	if in.Limit == 0 {
// 		in.Limit = l.svcCtx.Config.Query.DefaultAmount
// 	}

// 	if in.Limit > 0 {
// 		q = q.Limit(uint64(in.Limit) + 1)
// 	}

// 	ids, err := l.svcCtx.BlogPageModel.QueryIds(l.ctx, q)
// 	if err != nil {
// 		return nil, err
// 	}
// 	return nil, nil
// }

// func (l *PageListLogic) QueryList(objectIds []int64, nextId int64) (*blog.ObjectListResponse, error) {
	// ids := sqrlx.UniqueInt64(objectIds)

	// q := l.svcCtx.BlogPageModel.RowBuilder("", "")
	// q = q.Where(sq.Eq{"ID": ids})
	// pageList, err := l.svcCtx.BlogPageModel.QueryList(l.ctx, q)
	// if err != nil {
	// 	return nil, err
	// }

	// pages := make([]*blog.PageDetailResponse, 0, len(ids))
	// for _, page := range pageList {
	// 	pages = append(pages, &blog.PageDetailResponse{
	// 		Id:     page.ID,
	// 		Status: page.PostStatus,
	// 		Slug:   page.PostName,
	// 		Uri:    page.Guid,
	// 	})
	// }

// 	return &blog.ObjectListResponse{
// 		NextId: nextId,
// 		Page:   pages,
// 	}, nil
// }
